
package com.greencat.gwt.comet.server.impl;

import com.google.gwt.rpc.server.ClientOracle;
import com.google.gwt.rpc.server.HostedModeClientOracle;
import com.google.gwt.rpc.server.WebModeClientOracle;
import com.google.gwt.user.server.rpc.SerializationPolicy;
import java.io.IOException;
import java.io.InputStream;
import java.lang.ref.SoftReference;
import java.net.MalformedURLException;
import java.net.URL;
import java.util.HashMap;
import java.util.Map;
import javax.servlet.ServletContext;
import javax.servlet.http.HttpServletRequest;
import com.greencat.gwt.comet.client.impl.CometTransport;

/**
 *
 * @author p.havelaar
 */
public class GwtUtil {

	protected static final String CLIENT_ORACLE_EXTENSION = ".gwt.rpc";

	public static SerializationPolicy createSerializationPolicy() {
		return new SerializationPolicy() {
			@Override
			public boolean shouldDeserializeFields(final Class<?> clazz) {
				throw new UnsupportedOperationException("shouldDeserializeFields");
			}

			@Override
			public boolean shouldSerializeFields(final Class<?> clazz) {
				return Object.class != clazz;
			}

			@Override
			public void validateDeserialize(final Class<?> clazz) {
				throw new UnsupportedOperationException("validateDeserialize");
			}

			@Override
			public void validateSerialize(final Class<?> clazz) {
			}
		};
	}

	protected static ClientOracle getClientOracle(HttpServletRequest request, ServletContext context) throws IOException {
		String permutationStrongName = request.getParameter(CometTransport.STRONG_NAME_PARAMETER);
		if (permutationStrongName == null) {
			return null;
		}

		ClientOracle toReturn;
		synchronized (clientOracleCache) {
			if (clientOracleCache.containsKey(permutationStrongName)) {
				toReturn = clientOracleCache.get(permutationStrongName).get();
				if (toReturn != null) {
					return toReturn;
				}
			}

			if ("HostedMode".equals(permutationStrongName)) {
				// if (!allowHostedModeConnections()) {
				// throw new SecurityException("Blocked hosted mode request");
				// }
				toReturn = new HostedModeClientOracle();
			}
			else {
				String moduleBase = request.getParameter(CometTransport.MODULE_BASE_PARAMETER);
				if (moduleBase == null) {
					return null;
				}

				String basePath = new URL(moduleBase).getPath();
				if (basePath == null) {
					throw new MalformedURLException("Blocked request without GWT base path parameter (XSRF attack?)");
				}

				String contextPath = context.getContextPath();
				if (!basePath.startsWith(contextPath)) {
					throw new MalformedURLException("Blocked request with invalid GWT base path parameter (XSRF attack?)");
				}
				basePath = basePath.substring(contextPath.length());

				InputStream in = findClientOracleData(basePath, permutationStrongName, context);

				toReturn = WebModeClientOracle.load(in);
			}
			clientOracleCache.put(permutationStrongName, new SoftReference<ClientOracle>(toReturn));
		}

		return toReturn;
	}

	private static InputStream findClientOracleData(String requestModuleBasePath, String permutationStrongName
            , ServletContext context) throws IOException {
		String resourcePath = requestModuleBasePath + permutationStrongName + CLIENT_ORACLE_EXTENSION;
		InputStream in = context.getResourceAsStream(resourcePath);
		if (in == null) {
			throw new IOException("Could not find ClientOracle data for permutation " + permutationStrongName);
		}
		return in;
	}

	private static final Map<String, SoftReference<ClientOracle>> clientOracleCache = new HashMap<String, SoftReference<ClientOracle>>();

}
